Classic Edition: the symbol ⍤ is not available in Classic Edition, and the Rank operator is instead represented by ⎕U2364.
The Rank operator ⍤ applies monadic function f successively to sub-arrays of Y, or dyadic function f between sub-arrays of X and Y. Sub-arrays are selected by right operand B.
B is a numeric scalar or vector of up to three items, specifying the ranks of the cells to which f should be applied. The most general form is a three item vector p q r, where:
If B is a two item vector q r, it is implicitly extended to r q r. If B has a single item r, it is implicitly extended to r r r.
If an item k of B is zero or positive it selects k-cells of the corresponding argument. If it is negative, it selects (r+k)-cells where r is the rank of the corresponding argument. A value of ¯1 selects major cells. For further information, see Cells and Sub-arrays.
If X is omitted, f may be any monadic function that returns a result. Y may be any array. The Rank operator ⍤ applies function f successively to the sub-arrays in Y specified by p (i.e. the first item of B, as specified or implicitly extended).
If X is specified, it may be any array and f may be any dyadic function that returns a result. Y may be any array. In this case, the Rank operator applies function f successively between the sub-arrays in X specified by q and the sub-arrays in Y specified by r.
The sub-arrays of R are the results of the individual applications of f. If these results differ in rank or shape, they are extended to a common rank and shape in the manner of Mix. See Mix.
Notice that it is necessary to prevent the right operand k binding to the right argument. This can be done using parentheses e.g. (f⍤1)Y. The same can be achieved using ⊢ e.g. f⍤1⊢Y because ⍤ binds tighter to its right operand than ⊢ does to its left argument, and ⊢ therefore resolves to Identity.
Using enclose (⊂) as the left operand elucidates the workings of the rank operator.
Y
36 99 20 5
63 50 26 10
64 90 68 98
66 72 27 74
44 1 46 62
48 9 81 22
⍴Y
2 3 4⊂⍤2 ⊢Y ┌───────────┬───────────┐ │36 99 20 5│66 72 27 74│ │63 50 26 10│44 1 46 62│ │64 90 68 98│48 9 81 22│ └───────────┴───────────┘
⊂⍤1 ⊢Y ┌───────────┬───────────┬───────────┐ │36 99 20 5 │63 50 26 10│64 90 68 98│ ├───────────┼───────────┼───────────┤ │66 72 27 74│44 1 46 62 │48 9 81 22 │ └───────────┴───────────┴───────────┘
The function {(⊂⍋⍵)⌷⍵} sorts a vector.
{(⊂⍋⍵)⌷⍵} 3 1 4 1 5 9 2 6 5
1 1 2 3 4 5 5 6 9
The rank operator can be used to apply the function to sub-arrays; in this case to sort the 1-cells (rows) of a 3-dimensional array.
Y
36 99 20 5
63 50 26 10
64 90 68 98
66 72 27 74
44 1 46 62
48 9 81 22 ({(⊂⍋⍵)⌷⍵}⍤1)Y
5 20 36 99
10 26 50 63
64 68 90 98
27 66 72 74
1 44 46 62
9 22 48 81
10 20 30 (+⍤0 1)3 4⍴⍳12
10 11 12 13
24 25 26 27
38 39 40 41
Using the function {⍺ ⍵} as the left operand demonstrates how the dyadic case of the rank operator works.
10 20 30 ({⍺ ⍵}⍤0 1)3 4⍴⍳12
┌──┬─────────┐
│10│0 1 2 3 │
├──┼─────────┤
│20│4 5 6 7 │
├──┼─────────┤
│30│8 9 10 11│
└──┴─────────┘
Note that a right operand of ¯1 applies the function between the major cells (in this case elements) of the left argument, and the major cells (in this case rows) of the right argument.
10 20 30 ({⍺ ⍵}⍤¯1)3 4⍴⍳12
┌──┬─────────┐
│10│0 1 2 3 │
├──┼─────────┤
│20│4 5 6 7 │
├──┼─────────┤
│30│8 9 10 11│
└──┴─────────┘